home *** CD-ROM | disk | FTP | other *** search
/ Power Programmierung / Power-Programmierung (Tewi)(1994).iso / magazine / msysjour / vol06 / 03 / wintro6 / graph.c < prev    next >
C/C++ Source or Header  |  1991-05-01  |  20KB  |  616 lines
  1. /*=================================================================*/
  2. /*                                                                 */
  3. /* File    : GRAPH.C                                               */
  4. /*                                                                 */
  5. /* Purpose : Render the graphs for the stock charts                */
  6. /*                                                                 */
  7. /* History :                                                       */
  8. /*                                                                 */
  9. /* (C) Copyright 1989,1990 Marc Adler/Magma Systems                */
  10. /*=================================================================*/
  11.  
  12. #include <stdio.h>
  13. #include <string.h>
  14. #include <windows.h>
  15. #include "stock.h"
  16.  
  17. void FAR PASCAL HandleSelectionState(LPDRAWITEMSTRUCT lpdis,
  18.                                      int inflate);
  19. void FAR PASCAL HandleFocusState(LPDRAWITEMSTRUCT lpdis,
  20.                                      int inflate);
  21. void FAR PASCAL DrawEntireItem(LPDRAWITEMSTRUCT lpdis,
  22.                                      int inflate);
  23.  
  24.  
  25. BOOL FAR PASCAL
  26. GraphOptionsDlgProc(hDlg, message, wParam, lParam)
  27.   HWND hDlg;
  28.   unsigned message;
  29.   WORD wParam;
  30.   LONG lParam;
  31. {
  32.   int         iPen; 
  33.   char        szBuf[80];
  34.   static HANDLE      hStockInfo = NULL;
  35.   static LPSTOCKINFO lpStockInfo = (LPSTOCKINFO) NULL;
  36.   LPGRAPHINFO lpGraphInfo;
  37.   HWND        hWnd;
  38.   BOOL        bTranslated;
  39.  
  40.  
  41.   switch (message)
  42.   {
  43.     case WM_INITDIALOG :
  44.       if ((hStockInfo = (HANDLE) lParam) == NULL)
  45.       {
  46.         EndDialog(hDlg, IDCANCEL);
  47.         return TRUE;
  48.       }
  49.  
  50.       if ((lpStockInfo = (LPSTOCKINFO) GlobalLock(hStockInfo)) == NULL)
  51.       {
  52.         EndDialog(hDlg, IDCANCEL);
  53.         return TRUE;
  54.       }
  55.   
  56.       lpGraphInfo = &lpStockInfo->StockFile.graphinfo;
  57.  
  58.       /*
  59.         If the ticks array has some memory allocated to it, it means
  60.         that we are dealing with an existing stock. If not, then we
  61.         are creating a new stock.
  62.       */
  63.       if (lpStockInfo->hTicks != NULL)
  64.       {
  65.         SetDlgItemText(hDlg, ID_SYMBOL, 
  66.                       lpStockInfo->StockFile.szStock);
  67.         SetDlgItemInt(hDlg, ID_MINPRICE,
  68.                       (int) lpGraphInfo->dwMinPrice, FALSE);
  69.         SetDlgItemInt(hDlg, ID_MAXPRICE,
  70.                       (int) lpGraphInfo->dwMaxPrice, FALSE);
  71.         SetDlgItemInt(hDlg, ID_FACTOR,
  72.                       (int)lpGraphInfo->dwScaleFactor,FALSE);
  73.         SetDlgItemInt(hDlg, ID_TICKINT,
  74.                       (int)lpGraphInfo->dwTickInterval,FALSE);
  75.         SetDlgItemInt(hDlg, ID_DENOMINATOR,
  76.                       (int) lpGraphInfo->iDenominator, FALSE);
  77.  
  78.         if (lpStockInfo->dwFlags & STATE_HAS_VGRID)
  79.           CheckDlgButton(hDlg, ID_VERTGRID, TRUE);
  80.         if (lpStockInfo->dwFlags & STATE_HAS_HGRID)
  81.           CheckDlgButton(hDlg, ID_HORZGRID, TRUE);
  82.  
  83.         EnableWindow(GetDlgItem(hDlg, ID_SYMBOL), FALSE);
  84.       }
  85.       else
  86.       {
  87.         lpGraphInfo->iGridPen = 0;
  88.       }
  89.  
  90.  
  91.       /* 
  92.         Fill the listbox with pen ids 
  93.       */ 
  94.       for (iPen = 0;  iPen < PS_NULL;  iPen++) 
  95.         SendDlgItemMessage(hDlg, ID_GRIDSTYLE, CB_ADDSTRING, 0,
  96.                               (LONG) iPen); 
  97.       SendDlgItemMessage(hDlg,ID_GRIDSTYLE,CB_SETCURSEL,
  98.                               lpGraphInfo->iGridPen,0L);
  99.       return TRUE;
  100.  
  101.  
  102.     case WM_MEASUREITEM : 
  103.     { 
  104.       LPMEASUREITEMSTRUCT lpMI = (LPMEASUREITEMSTRUCT)(LPSTR)lParam;
  105.       lpMI->itemWidth  = 42; 
  106.       lpMI->itemHeight = 20; 
  107.       break; 
  108.     } 
  109.  
  110.     case WM_DRAWITEM : 
  111.     { 
  112.       LPDRAWITEMSTRUCT lpdis = (LPDRAWITEMSTRUCT) (LPSTR) lParam; 
  113.  
  114.       if (lpdis->itemID == -1)
  115.       {
  116.         HandleFocusState(lpdis, -5);
  117.         break;
  118.       }
  119.  
  120.       switch (lpdis->itemAction) 
  121.       { 
  122.         case ODA_DRAWENTIRE: 
  123.           DrawEntireItem(lpdis, -4); 
  124.           break; 
  125.  
  126.         case ODA_SELECT: 
  127.           HandleSelectionState(lpdis, 0); 
  128.           break; 
  129.  
  130.         case ODA_FOCUS: 
  131.           HandleFocusState(lpdis, -2); 
  132.           break; 
  133.       } 
  134.  
  135.       break; 
  136.     } 
  137.  
  138.  
  139.     case WM_COMMAND :
  140.       switch (wParam)
  141.       {
  142.         case IDOK :
  143.           lpGraphInfo = &lpStockInfo->StockFile.graphinfo;
  144.  
  145.           if (lpStockInfo->hTicks == NULL)
  146.           {
  147.             GetDlgItemText(hDlg, ID_SYMBOL, szBuf, sizeof(szBuf));
  148.             if (*szBuf == '\0')
  149.             {
  150.               MessageBox(hWndMain,
  151.                          "You must fill in the name of the stock.",
  152.                          "Error", MB_OK);
  153.               return TRUE;
  154.             }
  155.             strcat(szBuf, ".STO");
  156.             lstrcpy(lpStockInfo->szFileName, szBuf);
  157.  
  158.             lpStockInfo->StockFile.dwMagic = MAGIC_COOKIE;
  159.             if ((lpStockInfo->hTicks = GlobalAlloc(GMEM_MOVEABLE, 
  160.                                        (DWORD) sizeof(TICK) * 64)) == NULL)
  161.             {
  162.               MessageBox(hWndMain, "Can't allocate the ticker array",
  163.                                    "Error", MB_OK);
  164.               goto bye;
  165.             }
  166.             lpStockInfo->nTicksAllocated = 64;
  167.             lpStockInfo->StockFile.nTicks = 0;
  168.  
  169.             /*
  170.               Create a window for this guy
  171.             */
  172.             hWnd = lpStockInfo->hWnd = 
  173.                   GraphCreateWindow((LPSTR) szBuf);
  174.             SetWindowWord(lpStockInfo->hWnd, 0, hStockInfo);
  175.             lpStockInfo->dwFlags |= STATE_DIRTY;
  176.           }
  177.  
  178.           GetDlgItemText(hDlg, ID_SYMBOL,
  179.                          lpStockInfo->StockFile.szStock,
  180.                          sizeof(lpStockInfo->StockFile.szStock));
  181.           lpGraphInfo->dwMinPrice = 
  182.               GetDlgItemLong(hDlg, ID_MINPRICE,
  183.                             (BOOL FAR *) &bTranslated, FALSE);
  184.           lpGraphInfo->dwMaxPrice = 
  185.               GetDlgItemLong(hDlg, ID_MAXPRICE,
  186.                             (BOOL FAR *) &bTranslated, FALSE);
  187.           lpGraphInfo->dwScaleFactor = 
  188.               GetDlgItemLong(hDlg, ID_FACTOR,
  189.                             (BOOL FAR *) &bTranslated, FALSE);
  190.           lpGraphInfo->dwTickInterval = 
  191.               GetDlgItemLong(hDlg, ID_TICKINT,
  192.                             (BOOL FAR *) &bTranslated, FALSE);
  193.           lpGraphInfo->iDenominator = 
  194.               GetDlgItemInt(hDlg, ID_DENOMINATOR,
  195.                             (BOOL FAR *) &bTranslated, FALSE);
  196.           lpGraphInfo->iGridPen = (WORD)
  197.              SendDlgItemMessage(hDlg,ID_GRIDSTYLE,CB_GETCURSEL,0,0L);
  198.  
  199.           lpStockInfo->dwFlags &= ~(STATE_HAS_VGRID|STATE_HAS_HGRID);
  200.           if (IsDlgButtonChecked(hDlg, ID_VERTGRID))
  201.             lpStockInfo->dwFlags |= STATE_HAS_VGRID;
  202.           if (IsDlgButtonChecked(hDlg, ID_HORZGRID))
  203.             lpStockInfo->dwFlags |= STATE_HAS_HGRID;
  204.  
  205. bye:
  206.           InvalidateRect(lpStockInfo->hWnd, (LPRECT) NULL, FALSE);
  207.           GlobalUnlock(hStockInfo);
  208.           EndDialog(hDlg, IDOK);
  209.           break;
  210.  
  211.         case IDCANCEL:
  212.           GlobalUnlock(hStockInfo);
  213.           EndDialog(hDlg, IDCANCEL);
  214.           break;
  215.       }
  216.       return TRUE;
  217.  
  218.   } /* end switch (message) */
  219.  
  220.   return FALSE;
  221. }
  222.  
  223.  
  224. /**************************************************************************** 
  225.  *                                                                          * 
  226.  *  FUNCTION   : HandleSelectionState(LPDRAWITEMSTRUCT, int)                * 
  227.  *                                                                          * 
  228.  *  PURPOSE    : Handles a change in an item selection state. If an item is * 
  229.  *               selected, a black rectangular frame is drawn around that   * 
  230.  *               item; if an item is de-selected, the frame is removed.     * 
  231.  *                                                                          * 
  232.  *  COMMENT    : The black selection frame is slightly larger than the gray * 
  233.  *               focus frame so they won't paint over each other.           * 
  234.  *                                                                          * 
  235.  ****************************************************************************/ 
  236. void FAR PASCAL HandleSelectionState(lpdis, inflate) 
  237.   LPDRAWITEMSTRUCT  lpdis; 
  238.   int               inflate; 
  239. { 
  240.   HBRUSH hbr = (lpdis->itemState & ODS_SELECTED) ? 
  241.                   GetStockObject(BLACK_BRUSH)    :
  242.                   CreateSolidBrush(GetSysColor(COLOR_WINDOW)); 
  243.   FrameRect(lpdis->hDC, (LPRECT) &lpdis->rcItem, hbr); 
  244.   DeleteObject (hbr); 
  245. } 
  246.  
  247.  
  248. /**************************************************************************** 
  249.  *                                                                          * 
  250.  *  FUNCTION   : HandleFocusState(LPDRAWITEMSTRUCT, int)                    * 
  251.  *                                                                          * 
  252.  *  PURPOSE    : Handle a change in item focus state. If an item gains the  * 
  253.  *               input focus, a gray rectangular frame is drawn around that * 
  254.  *               item; if an item loses the input focus, the gray frame is  * 
  255.  *               removed.                                                   * 
  256.  *                                                                          * 
  257.  *  COMMENT    : The gray focus frame is slightly smaller than the black    * 
  258.  *               selection frame so they won't paint over each other.       * 
  259.  *                                                                          * 
  260.  ****************************************************************************/ 
  261. void FAR PASCAL HandleFocusState(lpdis, inflate) 
  262.   LPDRAWITEMSTRUCT  lpdis; 
  263.   int      inflate; 
  264. { 
  265.   RECT  rc; 
  266.   HBRUSH  hbr; 
  267.  
  268.   /* Resize rectangle to place focus frame between the selection 
  269.    * frame and the item. 
  270.    */ 
  271.   CopyRect ((LPRECT)&rc, (LPRECT)&lpdis->rcItem); 
  272.   InflateRect ((LPRECT)&rc, inflate, inflate); 
  273.  
  274.   if (lpdis->itemState & ODS_FOCUS) 
  275.     /* gaining input focus -- paint a gray frame */ 
  276.     hbr = GetStockObject(GRAY_BRUSH); 
  277.   else 
  278.     /* losing input focus -- remove (paint over) frame */ 
  279.     hbr = CreateSolidBrush(GetSysColor(COLOR_WINDOW)); 
  280.  
  281.   FrameRect(lpdis->hDC, (LPRECT)&rc, hbr); 
  282.   DeleteObject (hbr); 
  283. } 
  284.  
  285. /******************************************************************** 
  286.  *                                                                  * 
  287.  *  FUNCTION   : DrawEntireItem(LPDRAWITEMSTRUCT, int)              * 
  288.  *                                                                  * 
  289.  *  PURPOSE    : Draws an item and frames it with a selection frame *
  290.                  and/or a focus frame when appropriate.             * 
  291.  *                                                                  * 
  292.  *******************************************************************/ 
  293. void FAR PASCAL DrawEntireItem(lpdis, inflate) 
  294.   LPDRAWITEMSTRUCT  lpdis; 
  295.   int      inflate; 
  296. { 
  297.   RECT   rc; 
  298.   HANDLE hOldPen; 
  299.   HPEN   hPen; 
  300.  
  301.   if (lpdis->itemData < 0)
  302.     return;
  303.  
  304.   /* Resize rectangle to leave space for frames */ 
  305.   CopyRect ((LPRECT)&rc, (LPRECT)&lpdis->rcItem); 
  306.   InflateRect ((LPRECT)&rc, inflate, inflate); 
  307.  
  308.   if (lpdis->itemState & ODS_FOCUS) 
  309.     hPen = CreatePen((int)lpdis->itemData, 1, RGB(0xFF, 0xFF, 0xFF)); 
  310.   else
  311.     hPen = CreatePen((int) lpdis->itemData, 1, RGB(0, 0, 0)); 
  312.   hOldPen = SelectObject(lpdis->hDC, hPen); 
  313.  
  314.   MoveTo(lpdis->hDC, rc.left,  rc.top + (rc.bottom - rc.top) / 2); 
  315.   LineTo(lpdis->hDC, rc.right, rc.top + (rc.bottom - rc.top) / 2); 
  316.  
  317.   SelectObject(lpdis->hDC, hOldPen); 
  318.   DeleteObject(hPen); 
  319.  
  320.   /* Draw or erase appropriate frames */ 
  321.   HandleSelectionState(lpdis, inflate + 4); 
  322.   HandleFocusState(lpdis, inflate + 2); 
  323. } 
  324.  
  325.  
  326. int PASCAL GraphWndPaint(HWND hWnd, HDC hDC, LPSTOCKINFO lpStockInfo, BOOL bPrinting)
  327. {
  328.   RECT         r;
  329.   int          i, x, y;
  330.   int          xGraph, yGraph;
  331.   LPTICK       lpTick;
  332.   int          rangeHigh,
  333.                rangeLow,
  334.                xPixelsPerDate,
  335.                yTickInterval;
  336.   int          yAxisStart, xAxisStart;
  337.   HANDLE       hOldPen;
  338.   HPEN         hPen;
  339.   HBRUSH       hBrush;
  340.   HFONT        hFont, hOldFont;
  341.   TEXTMETRIC   tm;
  342.   char         szBuf[80];
  343.  
  344.   if (lpStockInfo->StockFile.nTicks == 0)
  345.     return TRUE;
  346.  
  347.   if ((lpTick = (LPTICK) GlobalLock(lpStockInfo->hTicks)) == NULL)
  348.     return TRUE;
  349.  
  350.  
  351.   /*
  352.     Get the client dimensions of the current stock window and figure
  353.     out the width and height of the graph.
  354.   */
  355.   if (bPrinting)
  356.   {
  357.     yGraph = GetDeviceCaps(hDC, VERTRES);
  358.     xGraph = GetDeviceCaps(hDC, HORZRES);
  359.   }
  360.   else
  361.   {
  362.     GetClientRect(hWnd, (LPRECT) &r);
  363.     yGraph = r.bottom - r.top;
  364.     xGraph = r.right - r.left;
  365.   }
  366.  
  367.   /*
  368.     Erase the background to the desired color
  369.   */
  370.   if (!bPrinting)
  371.   {
  372.     hBrush = CreateSolidBrush(lpStockInfo->graphAttrs.clrBackground);
  373.     FillRect(hDC, (LPRECT) &r, hBrush);
  374.     DeleteObject(hBrush);
  375.   }
  376.  
  377.   /*
  378.     Get the low and high range into local variables.
  379.   */
  380.   rangeHigh = (int) lpStockInfo->StockFile.graphinfo.dwMaxPrice;
  381.   rangeLow  = (int) lpStockInfo->StockFile.graphinfo.dwMinPrice;
  382.   if ((yTickInterval = 
  383.         (int) lpStockInfo->StockFile.graphinfo.dwTickInterval) < 1)
  384.     yTickInterval = 1;
  385.  
  386.   /*
  387.     Get the metrics of the current font.
  388.   */
  389.   hOldFont = NULL;
  390.   if (lpStockInfo->graphAttrs.hFont)
  391.     hOldFont = SelectObject(hDC, lpStockInfo->graphAttrs.hFont);
  392.   GetTextMetrics(hDC, (LPTEXTMETRIC) &tm);
  393.  
  394.  
  395.   /*
  396.     Set up the mapping mode. Y-axis points up and X-axis points right.
  397.   */
  398.   SetMapMode(hDC, lpStockInfo->graphAttrs.iMappingMode);
  399.   SetWindowExt(hDC,  xGraph, yGraph);
  400.   SetViewportExt(hDC, xGraph, -yGraph);
  401.   SetViewportOrg(hDC, 0, yGraph);
  402.  
  403.   sprintf(szBuf, "%d", rangeHigh);
  404.   yAxisStart = strlen(szBuf) * (tm.tmAveCharWidth + 1);
  405.   xAxisStart = tm.tmHeight + (tm.tmHeight/2);
  406.   xPixelsPerDate = xGraph / lpStockInfo->StockFile.nTicks;
  407.  
  408.   /*
  409.     Set the background drawing mode to TRANSPARENT so that the spaces
  410.     in between the letters and grid lines get filled with the
  411.     background color.
  412.   */
  413.   SetBkMode(hDC, TRANSPARENT);
  414.  
  415.   /*
  416.     Draw the axises. First the Y-axis, then the X-axis.
  417.   */
  418.   MoveTo(hDC, yAxisStart, xAxisStart);
  419.   LineTo(hDC, yAxisStart, yGraph);
  420.   MoveTo(hDC, yAxisStart, xAxisStart);
  421.   LineTo(hDC, xGraph,     xAxisStart);
  422.  
  423.   /*
  424.     Draw the hash marks for the x-axis
  425.   */
  426.   for (i = 1;  i < lpStockInfo->StockFile.nTicks;  i++)
  427.   {
  428.     int x = i * xPixelsPerDate + yAxisStart;
  429.     int iTextLen;
  430.     MoveTo(hDC, x, xAxisStart-2);
  431.     LineTo(hDC, x, xAxisStart+2);
  432.     sprintf(szBuf, "%d", i+1);
  433.     iTextLen = strlen(szBuf) * tm.tmAveCharWidth;
  434.     /*
  435.       Output the x-axis text centered over the hash mark
  436.     */
  437.     TextOut(hDC, x-(iTextLen>>1), xAxisStart-2, szBuf,strlen(szBuf));
  438.   }
  439.  
  440.   /*
  441.     Draw the hash marks for the y-axis
  442.   */
  443.   for (i = rangeLow;  i <= rangeHigh;
  444.        i += yTickInterval)
  445.   {
  446.     int y = (int) ((long) (i-rangeLow) * (long) (yGraph-xAxisStart) /
  447.                            (rangeHigh-rangeLow) + xAxisStart);
  448.     if (i > rangeLow)
  449.     {
  450.       MoveTo(hDC, yAxisStart-4, y);
  451.       LineTo(hDC, yAxisStart+4, y);
  452.     }
  453.     sprintf(szBuf, "%d", i);
  454.     TextOut(hDC, 0, y + (tm.tmHeight >> 1), szBuf, strlen(szBuf));
  455.   }
  456.  
  457.  
  458.   /*
  459.     Now draw the horizontal and vertical grid lines.
  460.   */
  461.   hPen = CreatePen(lpStockInfo->StockFile.graphinfo.iGridPen, 1, 
  462.                    lpStockInfo->graphAttrs.clrPen);
  463.   hOldPen = SelectObject(hDC, hPen);
  464.  
  465.   if (lpStockInfo->dwFlags & STATE_HAS_VGRID)
  466.   {
  467.     for (i = 0;  i < lpStockInfo->StockFile.nTicks;  i++)
  468.     {
  469.       int x = (i+1) * xPixelsPerDate + yAxisStart;
  470.       MoveTo(hDC, x, xAxisStart);
  471.       LineTo(hDC, x, yGraph);
  472.     }
  473.   }
  474.  
  475.   if (lpStockInfo->dwFlags & STATE_HAS_HGRID)
  476.   {
  477.     for (i = rangeLow + yTickInterval;  i <= rangeHigh;
  478.          i += yTickInterval)
  479.     {
  480.       int y = (int) ((long) (i-rangeLow) * (long) (yGraph-xAxisStart) /
  481.                         (rangeHigh - rangeLow) + xAxisStart);
  482.       MoveTo(hDC, yAxisStart, y);
  483.       LineTo(hDC, xGraph, y);
  484.     }
  485.   }
  486.  
  487.   SelectObject(hDC, hOldPen);
  488.   DeleteObject(hPen);
  489.  
  490.  
  491.   /*
  492.     Figure out how many pixels wide each entry should be. This is
  493.     equal to the width of the graph divided by the number of ticks 
  494.     to be plotted.
  495.   */
  496.   MoveTo(hDC, yAxisStart, (int) (xAxisStart + 
  497.           (long) (lpTick[0].price - rangeLow) * 
  498.                                    (long) yGraph / (rangeHigh - rangeLow)));
  499.   if (lpStockInfo->StockFile.nTicks == 1)
  500.   {
  501.     Ellipse(hDC, yAxisStart-2, xAxisStart-2, 
  502.                  yAxisStart+2, xAxisStart+2);
  503.   }
  504.   else
  505.   {
  506.     for (i = 1;  i < lpStockInfo->StockFile.nTicks;  i++)
  507.     {
  508.       int x = i * xPixelsPerDate;
  509.       int y = (int) ((lpTick[i].price - rangeLow) * (long) yGraph / 
  510.                                    (rangeHigh-rangeLow));
  511.       LineTo(hDC, x + yAxisStart, y + xAxisStart);
  512.       Ellipse(hDC, x+yAxisStart-2, y+xAxisStart-2, 
  513.                    x+yAxisStart+2, y+xAxisStart+2);
  514.     }
  515.   }
  516.  
  517.  
  518.   if (hOldFont)
  519.     SelectObject(hDC, hOldFont);
  520.   GlobalUnlock(lpStockInfo->hTicks);
  521.   return TRUE;
  522. }
  523.  
  524.  
  525. #include "rainbow.h"
  526.  
  527. BOOL FAR PASCAL GraphColorsDlgProc(hDlg, msg, wParam, lParam)
  528.   HWND hDlg;
  529.   WORD msg;
  530.   WORD wParam;
  531.   LONG lParam;
  532. {
  533.   LPSTOCKINFO lpStockInfo;
  534.   char        szMsg[80];
  535.  
  536.   switch (msg)
  537.   {
  538.     case WM_INITDIALOG:
  539.       /*
  540.          Make sure that there is a current stock information record
  541.          which we can append the ticker onto.
  542.       */
  543.       if (!hCurrStockInfo)
  544.       {
  545.         MessageBox(hDlg, "There is no current stock graph.", 
  546.                          "Error", MB_OK);
  547.         EndDialog(hDlg, FALSE);
  548.         return TRUE;
  549.       }
  550.  
  551.       lpStockInfo = (LPSTOCKINFO) GlobalLock(hCurrStockInfo);
  552.       if (lpStockInfo == NULL)
  553.       {
  554.         MessageBox(hDlg, "GlobalLock returned NULL", "Error", MB_OK);
  555.         EndDialog(hDlg, FALSE);
  556.         return TRUE;
  557.       }
  558.  
  559.       SendDlgItemMessage(hDlg, ID_PENCOLOR,  RM_SETSEL,
  560.                          lpStockInfo->graphAttrs.idxPen, 0L);
  561.       SendDlgItemMessage(hDlg, ID_BACKCOLOR, RM_SETSEL, 
  562.                          lpStockInfo->graphAttrs.idxBackground, 0L);
  563.  
  564.       GlobalUnlock(hCurrStockInfo);
  565.       return TRUE;
  566.  
  567.  
  568.     case WM_COMMAND:
  569.       switch (wParam)
  570.       {
  571.         /*
  572.           The user chose the OK button...
  573.         */
  574.         case IDOK:
  575.           /*
  576.             Get a pointer to the stock info record
  577.           */
  578.           lpStockInfo = (LPSTOCKINFO) GlobalLock(hCurrStockInfo);
  579.           if (lpStockInfo == NULL)
  580.           {
  581.             MessageBox(hDlg, "GlobalLock returned NULL", 
  582.                              "Error", MB_OK);
  583.             EndDialog(hDlg, FALSE);
  584.             break;
  585.           }
  586.  
  587.           lpStockInfo->graphAttrs.idxPen = (WORD)
  588.             SendDlgItemMessage(hDlg, ID_PENCOLOR,  RM_GETSEL, 0,
  589.                     (LONG) (LPSTR) &lpStockInfo->graphAttrs.clrPen);
  590.           lpStockInfo->graphAttrs.idxBackground = (WORD)
  591.             SendDlgItemMessage(hDlg, ID_BACKCOLOR, RM_GETSEL, 0,
  592.                     (LONG) (LPSTR)
  593.                             &lpStockInfo->graphAttrs.clrBackground);
  594.  
  595.           InvalidateRect(lpStockInfo->hWnd, (LPRECT) NULL, FALSE);
  596.           GlobalUnlock(hCurrStockInfo);
  597.           EndDialog(hDlg, TRUE);
  598.           break;
  599.  
  600.  
  601.         /*
  602.           The user chose the CANCEL button....
  603.         */
  604.         case IDCANCEL :
  605.           EndDialog(hDlg, FALSE);
  606.           break;
  607.       }
  608.       return TRUE;
  609.  
  610.     default:
  611.       return FALSE;
  612.   }
  613. }
  614.  
  615.  
  616.